import { window, Selection, workspace, WorkspaceConfiguration } from 'vscode'
import { ChineseCharacterItem } from '~/views/providers/ReplaceProvider'
import { Translator as TranslateEngine } from '~/translators'
import { Telemetry, TelemetryKey } from '~/core'
import { Log } from '~/utils'
import path from 'path'

/**
 * 将文本转换为驼峰命名格式
 * @param text 输入文本
 * @returns 驼峰命名格式的文本
 */
function toCamelCase(text: string): string {
  if (!text) return '';
  return text
    .toLowerCase()
    .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase())
    .replace(/^./, char => char.toUpperCase());
}

/**
 * 将中文字符翻译成英文并替换原文本
 */
export async function ReplaceTranslateKey(item?: ChineseCharacterItem) {
  if (!item || !item.text || !item.line) {
    return
  }

  Telemetry.track(TelemetryKey.TranslateKey, { actionSource: 'replace-panel' })

  try {
    // 获取活动编辑器
    const editor = window.activeTextEditor
    if (!editor) {
      return
    }

    // 创建翻译器实例
    const translator = new TranslateEngine()

    // 显示翻译进度
    window.withProgress({
      location: 15,
      title: '正在翻译中文字符...',
    }, async () => {
      try {
        // 执行翻译
        const result = await translator.translate({
          engine: 'difyai',
          text: item.text,
          from: 'zh-CN',
          to: 'en',
        })
        Log.info(`[Dify] translate result:`);
        Log.info(JSON.stringify(result));
        if (result.result?.length === 0) {
          throw new Error(result.error?.message)
        }
        // 获取文件的所有行
        const document = editor.document
        const fullText = document.getText()
        const lines = fullText.split('\n')

        // 找到包含中文字符的行
        if (lines.length >= item.line) {
          // 找到该行中的中文字符位置
          const targetLine = lines[item.line - 1]
          const charIndex = targetLine.indexOf(item.text)

          if (charIndex !== -1) {
            // 创建替换范围
            const startPos = document.positionAt(fullText.indexOf(item.text))
            const endPos = document.positionAt(fullText.indexOf(item.text) + item.text.length)

            // 执行替换
            await editor.edit(editBuilder => {
              // 获取文件路径信息
              const filePath = document.uri.fsPath;
              const workspaceFolder = workspace.getWorkspaceFolder(document.uri);

              let filePathPrefix = '';
              if (workspaceFolder) {
                // 计算相对路径
                let relativePath = path.relative(workspaceFolder.uri.fsPath, filePath);
                // 将路径分隔符统一转换为点
                relativePath = relativePath.replace(/[\\\/]/g, '.');
                // 移除文件扩展名
                const ext = path.extname(relativePath);
                if (ext) {
                  relativePath = relativePath.slice(0, -ext.length);
                }
                filePathPrefix = relativePath + '.';
              }

              // 获取翻译结果并转换为驼峰命名
              let translation = result.result?.[0] || item.text;
              translation = toCamelCase(translation);

              // 拼接翻译结果
              const translatedText = filePathPrefix + translation;

              // 获取配置的替换模板
              const config: WorkspaceConfiguration = workspace.getConfiguration('i18n-ally');
              const replacementTemplate: string = config.get('replaceTranslateKey.template', 'VALUE');

              // 使用翻译结果替换模板中的VALUE
              let finalText: string;
              if (replacementTemplate.includes('VALUE')) {
                // 只有当模板中包含'VALUE'字符串时才执行替换
                finalText = replacementTemplate.replace('VALUE', translatedText);
              } else {
                // 否则直接使用翻译后的文本
                finalText = translatedText;
              }

              // 执行替换
              editBuilder.replace(
                new Selection(startPos, endPos),
                finalText // 使用带路径前缀的翻译结果
              )
            })
          }
        }
      } catch (error) {
         Log.info(`翻译中文字符时出错:${error}`)
      }
    })
  } catch (error) {
    Log.info(`翻译中文字符时出错:${error}`)
  }
}
